// -------------------------------------------------------
// Bibliothèque de variables utilisées par l'application :
// -------------------------------------------------------
#define ENFLOAT
#define GRAND_B


	#ifdef ENFLOAT
		#define PRECISION float
		#define MAX 1200
		#define ENTIER unsigned int
	#else
		#define PRECISION double
		#define MAX 600
		#define ENTIER unsigned long long
	#endif

#define MAX_NUM_SPE_THREADS 6
// Définition du plan de travail a,b
// abs(A_MAX-A_MIN) doit être un multiple de 6
#define A_MIN (PRECISION) -1.0
#define A_MAX (PRECISION) 4.0
#define B_MIN (PRECISION) -1.0
#define B_MAX (PRECISION) 1.0

// Pas d'itération pour A et B
#define PAS_A (PRECISION)0.001
#define PAS_B (PRECISION)0.0005

// Nombre max de singularités : il doit être tel que (k*16-20)/20 soit multiple de 16
// <====> nombre_max_singus multiple de 4   + 3
#define nombre_max_singus 5


#define x_min (PRECISION)0.33
#define x_max (PRECISION)1.0
#define y_min (PRECISION)0.0317
#define y_max (PRECISION)1.0
#define x_satu_min (PRECISION)-1000.0
#define x_satu_max (PRECISION)1000.0
#define y_satu_min (PRECISION)-1000.0
#define y_satu_max (PRECISION)1000.0
#define EpsilonX (PRECISION)0.00001
#define EpsilonY (PRECISION)0.00001
#define NbInits (4*5)       // doit être un multiple de 4
#define NbVecsInit NbInits/4
#define NbItTransit 10000
#define OrdreMaxCycle 15
//#define NombreMaxVerifs 3

// NE PAS MODIFIER LE CODE APRES CE COMMENTAIRE


#define DIVERGE (1<<7)
#define CHAOS (1<<6)

// nombre de valeur totales de a = amin -amax /pas a // nombre de valeur totales de b = bmin -bmax /pas b
// NB_VAL_A * NB_VAL_B < 1200 sinon erreur de segmentation



#define NB_VAL_A (int)((( A_MAX-A_MIN)/PAS_A)+1)
#define NB_VAL_B (int)((( B_MAX-B_MIN)/PAS_B)+1)

#ifdef ENFLOAT
	#ifndef GRAND_B
		#define NB_DECOUPE 0
		#define NB_A  (int)( 1200/NB_VAL_B )
		#define NB_B NB_VAL_B
		#define INTERVALLE_A (NB_A*PAS_A)
	#else
		#define NB_DECOUPE (int)(NB_VAL_B/1200)
		#define NB_A (int) 1
		#define INTERVALLE_A (NB_A*PAS_A)
		#define NB_B MAX
	#endif
#else
	#ifndef GRAND_B
		#define NB_DECOUPE 1
		#define NB_A  (int)(600/NB_VAL_B )
		#define NB_B NB_VAL_B
		#define INTERVALLE_A (NB_A*PAS_A)
	#else
		#define NB_DECOUPE (int)(NB_VAL_B/600)
		#define NB_A (int) 1
		#define INTERVALLE_A (NB_A*PAS_A)
		#define NB_B MAX
	#endif
#endif

/*
#define NB_VAL_B  (int)(( B_MAX-B_MIN)/PAS_B)
#ifdef ENFLOAT
	#define NB_VAL_A  ((int) 1200/NB_VAL_B )
#else
	#define NB_VAL_A  ((int) 600/NB_VAL_B )
#endif
#define INTERVALLE_A (NB_VAL_A*PAS_A)
*/

#define colonnes ((int)NB_VAL_A*INTERVALLE_A)
#define lignes NB_VAL_B

// --------------------------------
// Définitions pour l'usage des DMA
// --------------------------------
#ifndef _UBICUS_H_
#define _UBICUS_H_




/* Here we define a control block data structure that contains 
 * all the data the SPE needed to get the large array of data into
 * local store.
 *
 * This data structure has a size that's a multiple of 16 bytes */
typedef struct _control_block
{
  PRECISION a_min;
  PRECISION b_min;
  unsigned int idA;
  unsigned long long addr;
#ifdef ENFLOAT
  long double douzebytes;
#endif

} control_block_t;

typedef struct
{
  int nombre_singus;
  int ca_diverge;
  int y_a_du_chaos;
  int ordre[nombre_max_singus+1];
  PRECISION x_point_min[nombre_max_singus+1];
  PRECISION y_point_min[nombre_max_singus+1];
} point_parametrique;

typedef struct
{
    int nombre_de_a;
    int nombre_de_b;
	point_parametrique tableau_points[NB_A][NB_B];
} balayage_a_b;

#endif /* _ubicus_h_ */
